﻿using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using Teigha.Core;

namespace Teigha.TD
{
	public class OdModelerGeometry : OdRxObject
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public OdModelerGeometry(IntPtr cPtr, bool cMemoryOwn) : base(TD_DbPINVOKE.OdModelerGeometry_SWIGUpcast(cPtr), cMemoryOwn)
		{
			this.swigCPtr = new HandleRef(this, cPtr);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static HandleRef getCPtr(OdModelerGeometry obj)
		{
			if (obj != null)
			{
				return obj.swigCPtr;
			}
			return new HandleRef(null, IntPtr.Zero);
		}

		~OdModelerGeometry()
		{
			this.Dispose();
		}

		public override void Dispose()
		{
			if (this.swigCPtr.Handle != IntPtr.Zero)
			{
				if (this.swigCMemOwn)
				{
					lock (this.locker)
					{
						if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
						{
							this.swigCMemOwn = false;
							TD_DbPINVOKE.delete_OdModelerGeometry(this.swigCPtr);
						}
					}
					this.swigCMemOwn = false;
				}
				this.swigCPtr = new HandleRef(null, IntPtr.Zero);
			}
			GC.SuppressFinalize(this);
			base.Dispose();
		}

		public new static OdModelerGeometry cast(OdRxObject pObj)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdModelerGeometry_cast(OdRxObject.getCPtr(pObj));
			OdModelerGeometry result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdModelerGeometry)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdModelerGeometry)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdModelerGeometry)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdRxClass desc()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdModelerGeometry_desc(), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxClass isA()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdModelerGeometry_isA(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxObject queryX(OdRxClass protocolClass)
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdModelerGeometry_queryX(this.swigCPtr, OdRxClass.getCPtr(protocolClass)), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdModelerGeometry createObject()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdModelerGeometry_createObject();
			OdModelerGeometry result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdModelerGeometry)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdModelerGeometry)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdModelerGeometry)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult _in(OdStreamBuf pStreamBuf, out int typeVer, bool standardSaveFlag)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry__in__SWIG_0(this.swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), out typeVer, standardSaveFlag);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult _in(OdStreamBuf pStreamBuf, out int typeVer)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry__in__SWIG_1(this.swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), out typeVer);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult _in(OdStreamBuf pStreamBuf)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry__in__SWIG_2(this.swigCPtr, OdStreamBuf.getCPtr(pStreamBuf));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult _out(OdStreamBuf pStreamBuf, int typeVer, bool standardSaveFlag)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry__out__SWIG_0(this.swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), typeVer, standardSaveFlag);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult _out(OdStreamBuf pStreamBuf, int typeVer)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry__out__SWIG_1(this.swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), typeVer);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool brep(OdBrBrep brBrep)
		{
			bool result = TD_DbPINVOKE.OdModelerGeometry_brep(this.swigCPtr, OdBrBrep.getCPtr(brBrep));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult setSubentPath(OdBrEntity arg0, OdDbFullSubentPath arg1)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setSubentPath(this.swigCPtr, OdBrEntity.getCPtr(arg0), OdDbFullSubentPath.getCPtr(arg1));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool setFACETRES(double facetRes)
		{
			bool result = TD_DbPINVOKE.OdModelerGeometry_setFACETRES(this.swigCPtr, facetRes);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool worldDraw(OdGiCommonDraw pWd, uint geomType, OdModelerGeometry.NumIsolines pNumIsolines)
		{
			bool result = TD_DbPINVOKE.OdModelerGeometry_worldDraw__SWIG_0(this.swigCPtr, OdGiCommonDraw.getCPtr(pWd), geomType, OdModelerGeometry.NumIsolines.getCPtr(pNumIsolines));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool worldDraw(OdGiCommonDraw pWd, uint geomType)
		{
			bool result = TD_DbPINVOKE.OdModelerGeometry_worldDraw__SWIG_1(this.swigCPtr, OdGiCommonDraw.getCPtr(pWd), geomType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool drawSilhouettes(OdGiViewportDraw pVd)
		{
			bool result = TD_DbPINVOKE.OdModelerGeometry_drawSilhouettes(this.swigCPtr, OdGiViewportDraw.getCPtr(pVd));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool explode(OdDbEntityPtrArray entitySet)
		{
			bool result = TD_DbPINVOKE.OdModelerGeometry_explode(this.swigCPtr, OdDbEntityPtrArray.getCPtr(entitySet));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool getTransformation(OdGeMatrix3d xfm)
		{
			bool result = TD_DbPINVOKE.OdModelerGeometry_getTransformation(this.swigCPtr, OdGeMatrix3d.getCPtr(xfm));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void transformBy(OdGeMatrix3d xfm)
		{
			TD_DbPINVOKE.OdModelerGeometry_transformBy(this.swigCPtr, OdGeMatrix3d.getCPtr(xfm));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void createBox(double xLen, double yLen, double zLen)
		{
			TD_DbPINVOKE.OdModelerGeometry_createBox(this.swigCPtr, xLen, yLen, zLen);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void createFrustum(double height, double xRadius, double yRadius, double topXRadius)
		{
			TD_DbPINVOKE.OdModelerGeometry_createFrustum(this.swigCPtr, height, xRadius, yRadius, topXRadius);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void createSphere(double radius)
		{
			TD_DbPINVOKE.OdModelerGeometry_createSphere(this.swigCPtr, radius);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void createTorus(double majorRadius, double minorRadius)
		{
			TD_DbPINVOKE.OdModelerGeometry_createTorus(this.swigCPtr, majorRadius, minorRadius);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void createWedge(double xLen, double yLen, double zLen)
		{
			TD_DbPINVOKE.OdModelerGeometry_createWedge(this.swigCPtr, xLen, yLen, zLen);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdResult extrude(OdDbRegion pRegion, double height, double taperAngle, bool isSolid)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrude__SWIG_0(this.swigCPtr, OdDbRegion.getCPtr(pRegion), height, taperAngle, isSolid);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult extrude(OdDbRegion pRegion, double height, double taperAngle)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrude__SWIG_1(this.swigCPtr, OdDbRegion.getCPtr(pRegion), height, taperAngle);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult revolve(OdDbRegion pRegion, OdGePoint3d axisPoint, OdGeVector3d axisDir, double angleOfRevolution, bool isSolid)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_revolve__SWIG_0(this.swigCPtr, OdDbRegion.getCPtr(pRegion), OdGePoint3d.getCPtr(axisPoint), OdGeVector3d.getCPtr(axisDir), angleOfRevolution, isSolid);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult revolve(OdDbRegion pRegion, OdGePoint3d axisPoint, OdGeVector3d axisDir, double angleOfRevolution)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_revolve__SWIG_1(this.swigCPtr, OdDbRegion.getCPtr(pRegion), OdGePoint3d.getCPtr(axisPoint), OdGeVector3d.getCPtr(axisDir), angleOfRevolution);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void ClearColorAttributes()
		{
			TD_DbPINVOKE.OdModelerGeometry_ClearColorAttributes(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void ClearMaterialAttributes()
		{
			TD_DbPINVOKE.OdModelerGeometry_ClearMaterialAttributes(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void ClearMaterialMapperAttributes()
		{
			TD_DbPINVOKE.OdModelerGeometry_ClearMaterialMapperAttributes(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdModelerGeometry.MaterialState hasMaterials()
		{
			OdModelerGeometry.MaterialState result = (OdModelerGeometry.MaterialState)TD_DbPINVOKE.OdModelerGeometry_hasMaterials(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool hasTrueColorAttributes()
		{
			bool result = TD_DbPINVOKE.OdModelerGeometry_hasTrueColorAttributes(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getPlane(OdGePlane regionPlane)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getPlane(this.swigCPtr, OdGePlane.getCPtr(regionPlane));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool setMMPerUnit(double mmPerUnit)
		{
			bool result = TD_DbPINVOKE.OdModelerGeometry_setMMPerUnit(this.swigCPtr, mmPerUnit);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool getMMPerUnit(out double mmPerUnit)
		{
			bool result = TD_DbPINVOKE.OdModelerGeometry_getMMPerUnit(this.swigCPtr, out mmPerUnit);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdModelerGeometry.geomType bodyType()
		{
			OdModelerGeometry.geomType result = (OdModelerGeometry.geomType)TD_DbPINVOKE.OdModelerGeometry_bodyType(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult booleanOper(BoolOperType operation, OdModelerGeometry otherRegion)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_booleanOper__SWIG_0(this.swigCPtr, (int)operation, OdModelerGeometry.getCPtr(otherRegion));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult booleanOper(BoolOperType operation, OdModelerGeometry pModelerPar, OdDbEntityPtrArray intersectionEntities)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_booleanOper__SWIG_1(this.swigCPtr, (int)operation, OdModelerGeometry.getCPtr(pModelerPar), OdDbEntityPtrArray.getCPtr(intersectionEntities));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getArea(out double regionArea)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getArea(this.swigCPtr, out regionArea);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getPerimeter(out double arg0)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getPerimeter(this.swigCPtr, out arg0);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getAreaProp(OdGePoint3d origin, OdGeVector3d xAxis, OdGeVector3d yAxis, out double perimeter, out double area, OdGePoint2d centroid, double[] momInertia, out double prodInertia, double[] prinMoments, OdGeVector2d prinAxes, double[] radiiGyration, OdGePoint2d extentsLow, OdGePoint2d extentsHigh)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getAreaProp(this.swigCPtr, OdGePoint3d.getCPtr(origin), OdGeVector3d.getCPtr(xAxis), OdGeVector3d.getCPtr(yAxis), out perimeter, out area, OdGePoint2d.getCPtr(centroid), momInertia, out prodInertia, prinMoments, OdGeVector2d.getCPtr(prinAxes), radiiGyration, OdGePoint2d.getCPtr(extentsLow), OdGePoint2d.getCPtr(extentsHigh));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult clear()
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_clear(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult extrudeAlongPath(OdDbRegion region, OdDbCurve path, double taperAngle, bool isSolid)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrudeAlongPath__SWIG_0(this.swigCPtr, OdDbRegion.getCPtr(region), OdDbCurve.getCPtr(path), taperAngle, isSolid);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult extrudeAlongPath(OdDbRegion region, OdDbCurve path, double taperAngle)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrudeAlongPath__SWIG_1(this.swigCPtr, OdDbRegion.getCPtr(region), OdDbCurve.getCPtr(path), taperAngle);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult extrudeAlongPath(OdDbRegion region, OdDbCurve path)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrudeAlongPath__SWIG_2(this.swigCPtr, OdDbRegion.getCPtr(region), OdDbCurve.getCPtr(path));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult imprintEntity(OdDbEntity pEntity)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_imprintEntity(this.swigCPtr, OdDbEntity.getCPtr(pEntity));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult checkInterference(OdDb3dSolid otherSolid, bool createNewSolid, out bool solidsInterfere, out OdDb3dSolid commonVolumeSolid)
		{
			IntPtr zero = IntPtr.Zero;
			OdResult result;
			try
			{
				OdResult odResult = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkInterference(this.swigCPtr, OdDb3dSolid.getCPtr(otherSolid), createNewSolid, out solidsInterfere, out zero);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
				result = odResult;
			}
			finally
			{
				commonVolumeSolid = (OdDb3dSolid)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
			}
			return result;
		}

		public virtual OdResult getMassProp(out double volume, OdGePoint3d centroid, double[] momInertia, double[] prodInertia, double[] prinMoments, OdGeVector3d prinAxes, double[] radiiGyration, OdGeExtents3d extents)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getMassProp(this.swigCPtr, out volume, OdGePoint3d.getCPtr(centroid), momInertia, prodInertia, prinMoments, OdGeVector3d.getCPtr(prinAxes), radiiGyration, OdGeExtents3d.getCPtr(extents));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getSection(OdGePlane plane, out OdDbRegion sectionRegion, OdDbEntityPtrArray pSectionCurves)
		{
			IntPtr zero = IntPtr.Zero;
			OdResult result;
			try
			{
				OdResult odResult = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSection__SWIG_0(this.swigCPtr, OdGePlane.getCPtr(plane), out zero, OdDbEntityPtrArray.getCPtr(pSectionCurves));
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
				result = odResult;
			}
			finally
			{
				sectionRegion = (OdDbRegion)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
			}
			return result;
		}

		public virtual OdResult getSection(OdGePlane plane, out OdDbRegion sectionRegion)
		{
			IntPtr zero = IntPtr.Zero;
			OdResult result;
			try
			{
				OdResult odResult = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSection__SWIG_1(this.swigCPtr, OdGePlane.getCPtr(plane), out zero);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
				result = odResult;
			}
			finally
			{
				sectionRegion = (OdDbRegion)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
			}
			return result;
		}

		public virtual OdResult getSlice(OdGePlane plane, bool getNegHalfToo, out OdDb3dSolid negHalfSolid)
		{
			IntPtr zero = IntPtr.Zero;
			OdResult result;
			try
			{
				OdResult odResult = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSlice__SWIG_0(this.swigCPtr, OdGePlane.getCPtr(plane), getNegHalfToo, out zero);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
				result = odResult;
			}
			finally
			{
				negHalfSolid = (OdDb3dSolid)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
			}
			return result;
		}

		public virtual OdResult getSlice(OdDbSurface pSurface, bool bGetNegHalfToo, out OdDb3dSolid pNegHalfSolid)
		{
			IntPtr zero = IntPtr.Zero;
			OdResult result;
			try
			{
				OdResult odResult = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSlice__SWIG_1(this.swigCPtr, OdDbSurface.getCPtr(pSurface), bGetNegHalfToo, out zero);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
				result = odResult;
			}
			finally
			{
				pNegHalfSolid = (OdDb3dSolid)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
			}
			return result;
		}

		public virtual OdResult cleanBody()
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_cleanBody(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult offsetBody(double offsetDistance)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_offsetBody(this.swigCPtr, offsetDistance);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult separateBody(OdDb3dSolidPtrArray newSolids)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_separateBody(this.swigCPtr, OdDb3dSolidPtrArray.getCPtr(newSolids));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createExtrudedObject(OdDbEntity pSweepEnt, OdGeVector3d directionVec, OdDbSweepOptions sweepOptions, bool isSolid)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createExtrudedObject__SWIG_0(this.swigCPtr, OdDbEntity.getCPtr(pSweepEnt), OdGeVector3d.getCPtr(directionVec), OdDbSweepOptions.getCPtr(sweepOptions), isSolid);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createExtrudedObject(OdDbEntity pSweepEnt, OdGeVector3d directionVec, OdDbSweepOptions sweepOptions)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createExtrudedObject__SWIG_1(this.swigCPtr, OdDbEntity.getCPtr(pSweepEnt), OdGeVector3d.getCPtr(directionVec), OdDbSweepOptions.getCPtr(sweepOptions));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createLoftedObject(OdDbEntityPtrArray crossSectionCurves, OdDbEntityPtrArray guideCurves, OdDbEntity pPathCurve, OdDbLoftOptions loftOptions, bool isSolid)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createLoftedObject__SWIG_0(this.swigCPtr, OdDbEntityPtrArray.getCPtr(crossSectionCurves), OdDbEntityPtrArray.getCPtr(guideCurves), OdDbEntity.getCPtr(pPathCurve), OdDbLoftOptions.getCPtr(loftOptions), isSolid);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createLoftedObject(OdDbEntityPtrArray crossSectionCurves, OdDbEntityPtrArray guideCurves, OdDbEntity pPathCurve, OdDbLoftOptions loftOptions)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createLoftedObject__SWIG_1(this.swigCPtr, OdDbEntityPtrArray.getCPtr(crossSectionCurves), OdDbEntityPtrArray.getCPtr(guideCurves), OdDbEntity.getCPtr(pPathCurve), OdDbLoftOptions.getCPtr(loftOptions));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createPyramid(double height, int sides, double radius, double topRadius)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createPyramid__SWIG_0(this.swigCPtr, height, sides, radius, topRadius);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createPyramid(double height, int sides, double radius)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createPyramid__SWIG_1(this.swigCPtr, height, sides, radius);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createRevolvedObject(OdDbEntity pRevEnt, OdGePoint3d axisPnt, OdGeVector3d axisDir, double revAngle, double startAngle, OdDbRevolveOptions revolveOptions, bool isSolid)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createRevolvedObject__SWIG_0(this.swigCPtr, OdDbEntity.getCPtr(pRevEnt), OdGePoint3d.getCPtr(axisPnt), OdGeVector3d.getCPtr(axisDir), revAngle, startAngle, OdDbRevolveOptions.getCPtr(revolveOptions), isSolid);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createRevolvedObject(OdDbEntity pRevEnt, OdGePoint3d axisPnt, OdGeVector3d axisDir, double revAngle, double startAngle, OdDbRevolveOptions revolveOptions)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createRevolvedObject__SWIG_1(this.swigCPtr, OdDbEntity.getCPtr(pRevEnt), OdGePoint3d.getCPtr(axisPnt), OdGeVector3d.getCPtr(axisDir), revAngle, startAngle, OdDbRevolveOptions.getCPtr(revolveOptions));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createSweptObject(OdDbEntity pSweepEnt, OdDbEntity pPathEnt, OdDbSweepOptions sweepOptions, bool isSolid)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createSweptObject__SWIG_0(this.swigCPtr, OdDbEntity.getCPtr(pSweepEnt), OdDbEntity.getCPtr(pPathEnt), OdDbSweepOptions.getCPtr(sweepOptions), isSolid);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createSweptObject(OdDbEntity pSweepEnt, OdDbEntity pPathEnt, OdDbSweepOptions sweepOptions)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createSweptObject__SWIG_1(this.swigCPtr, OdDbEntity.getCPtr(pSweepEnt), OdDbEntity.getCPtr(pPathEnt), OdDbSweepOptions.getCPtr(sweepOptions));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult checkCrossSectionCurves(OdDbEntityPtrArray crossSectionCurves, out bool allOpen, out bool allClosed, out bool allPlanar, bool displayErrorMessages)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkCrossSectionCurves__SWIG_0(this.swigCPtr, OdDbEntityPtrArray.getCPtr(crossSectionCurves), out allOpen, out allClosed, out allPlanar, displayErrorMessages);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult checkCrossSectionCurves(OdDbEntityPtrArray crossSectionCurves, out bool allOpen, out bool allClosed, out bool allPlanar)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkCrossSectionCurves__SWIG_1(this.swigCPtr, OdDbEntityPtrArray.getCPtr(crossSectionCurves), out allOpen, out allClosed, out allPlanar);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult checkGuideCurves(OdDbEntityPtrArray guideCurves, bool displayErrorMessages)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkGuideCurves__SWIG_0(this.swigCPtr, OdDbEntityPtrArray.getCPtr(guideCurves), displayErrorMessages);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult checkGuideCurves(OdDbEntityPtrArray guideCurves)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkGuideCurves__SWIG_1(this.swigCPtr, OdDbEntityPtrArray.getCPtr(guideCurves));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult checkPathCurve(OdDbEntity pPathCurve, bool displayErrorMessages)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkPathCurve__SWIG_0(this.swigCPtr, OdDbEntity.getCPtr(pPathCurve), displayErrorMessages);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult checkPathCurve(OdDbEntity pPathCurve)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkPathCurve__SWIG_1(this.swigCPtr, OdDbEntity.getCPtr(pPathCurve));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult checkSweepCurve(OdDbEntity pSweepEnt, out Planarity planarity, OdGePoint3d pnt, OdGeVector3d vec, out bool closed, out double approxArcLen, bool displayErrorMessages)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkSweepCurve__SWIG_0(this.swigCPtr, OdDbEntity.getCPtr(pSweepEnt), out planarity, OdGePoint3d.getCPtr(pnt), OdGeVector3d.getCPtr(vec), out closed, out approxArcLen, displayErrorMessages);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult checkSweepCurve(OdDbEntity pSweepEnt, out Planarity planarity, OdGePoint3d pnt, OdGeVector3d vec, out bool closed, out double approxArcLen)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkSweepCurve__SWIG_1(this.swigCPtr, OdDbEntity.getCPtr(pSweepEnt), out planarity, OdGePoint3d.getCPtr(pnt), OdGeVector3d.getCPtr(vec), out closed, out approxArcLen);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult checkSweepPathCurve(OdDbEntity pPathEnt, bool displayErrorMessages)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkSweepPathCurve__SWIG_0(this.swigCPtr, OdDbEntity.getCPtr(pPathEnt), displayErrorMessages);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult checkSweepPathCurve(OdDbEntity pPathEnt)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkSweepPathCurve__SWIG_1(this.swigCPtr, OdDbEntity.getCPtr(pPathEnt));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult checkRevolveCurve(OdDbEntity pRevEnt, OdGePoint3d axisPnt, OdGeVector3d axisDir, out bool closed, out bool endPointsOnAxis, out bool planar, bool displayErrorMessages)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkRevolveCurve__SWIG_0(this.swigCPtr, OdDbEntity.getCPtr(pRevEnt), OdGePoint3d.getCPtr(axisPnt), OdGeVector3d.getCPtr(axisDir), out closed, out endPointsOnAxis, out planar, displayErrorMessages);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult checkRevolveCurve(OdDbEntity pRevEnt, OdGePoint3d axisPnt, OdGeVector3d axisDir, out bool closed, out bool endPointsOnAxis, out bool planar)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkRevolveCurve__SWIG_1(this.swigCPtr, OdDbEntity.getCPtr(pRevEnt), OdGePoint3d.getCPtr(axisPnt), OdGeVector3d.getCPtr(axisDir), out closed, out endPointsOnAxis, out planar);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createFrom(OdDbEntity pFromEntity)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createFrom(this.swigCPtr, OdDbEntity.getCPtr(pFromEntity));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult convertToRegion(OdDbEntityPtrArray regions)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_convertToRegion(this.swigCPtr, OdDbEntityPtrArray.getCPtr(regions));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult thicken(double thickness, bool bBothSides, out OdDb3dSolid pSolid)
		{
			IntPtr zero = IntPtr.Zero;
			OdResult result;
			try
			{
				OdResult odResult = (OdResult)TD_DbPINVOKE.OdModelerGeometry_thicken(this.swigCPtr, thickness, bBothSides, out zero);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
				result = odResult;
			}
			finally
			{
				pSolid = (OdDb3dSolid)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
			}
			return result;
		}

		public virtual OdResult intersectWith(OdDbEntity ent, Intersect intType, OdGePoint3dArray points, IntPtr thisGsMarker, IntPtr otherGsMarker)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_intersectWith__SWIG_0(this.swigCPtr, OdDbEntity.getCPtr(ent), (int)intType, OdGePoint3dArray.getCPtr(points), thisGsMarker, otherGsMarker);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult intersectWith(OdDbEntity ent, Intersect intType, OdGePlane projPlane, OdGePoint3dArray points, IntPtr thisGsMarker, IntPtr otherGsMarker)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_intersectWith__SWIG_1(this.swigCPtr, OdDbEntity.getCPtr(ent), (int)intType, OdGePlane.getCPtr(projPlane), OdGePoint3dArray.getCPtr(points), thisGsMarker, otherGsMarker);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult copySubEntity(OdDbSubentId subentId, out OdDbEntity newEntity)
		{
			IntPtr zero = IntPtr.Zero;
			OdResult result;
			try
			{
				OdResult odResult = (OdResult)TD_DbPINVOKE.OdModelerGeometry_copySubEntity(this.swigCPtr, OdDbSubentId.getCPtr(subentId), out zero);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
				result = odResult;
			}
			finally
			{
				newEntity = (OdDbEntity)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
			}
			return result;
		}

		public virtual OdResult taperFaces(OdDbSubentIdArray faceSubentIds, OdGePoint3d basePoint, OdGeVector3d draftVector, double draftAngle)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_taperFaces(this.swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds), OdGePoint3d.getCPtr(basePoint), OdGeVector3d.getCPtr(draftVector), draftAngle);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult removeFaces(OdDbSubentIdArray faceSubentIds)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_removeFaces(this.swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult offsetFaces(OdDbSubentIdArray faceSubentIds, double offsetDistance)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_offsetFaces(this.swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds), offsetDistance);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult shellBody(OdDbSubentIdArray faceSubentIds, double offsetDistance)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_shellBody(this.swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds), offsetDistance);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult transformFaces(OdDbSubentIdArray faceSubentIds, OdGeMatrix3d matrix)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_transformFaces(this.swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds), OdGeMatrix3d.getCPtr(matrix));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getSubentPathsAtGsMarker(SubentType type, IntPtr gsMark, OdGePoint3d pickPoint, OdGeMatrix3d viewXform, OdDbFullSubentPathArray subentPaths, OdDbObjectIdArray entAndInsertStack)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSubentPathsAtGsMarker__SWIG_0(this.swigCPtr, (int)type, gsMark, OdGePoint3d.getCPtr(pickPoint), OdGeMatrix3d.getCPtr(viewXform), OdDbFullSubentPathArray.getCPtr(subentPaths), OdDbObjectIdArray.getCPtr(entAndInsertStack));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getSubentPathsAtGsMarker(SubentType type, IntPtr gsMark, OdGePoint3d pickPoint, OdGeMatrix3d viewXform, OdDbFullSubentPathArray subentPaths)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSubentPathsAtGsMarker__SWIG_1(this.swigCPtr, (int)type, gsMark, OdGePoint3d.getCPtr(pickPoint), OdGeMatrix3d.getCPtr(viewXform), OdDbFullSubentPathArray.getCPtr(subentPaths));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getGsMarkersAtSubentPath(OdDbFullSubentPath subPath, SWIGTYPE_p_OdGsMarkerArray gsMarkers)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getGsMarkersAtSubentPath(this.swigCPtr, OdDbFullSubentPath.getCPtr(subPath), SWIGTYPE_p_OdGsMarkerArray.getCPtr(gsMarkers));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbSubentId internalSubentId(IntPtr ent)
		{
			OdDbSubentId result = new OdDbSubentId(TD_DbPINVOKE.OdModelerGeometry_internalSubentId(this.swigCPtr, ent), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual IntPtr internalSubentPtr(OdDbSubentId id)
		{
			IntPtr result = TD_DbPINVOKE.OdModelerGeometry_internalSubentPtr(this.swigCPtr, OdDbSubentId.getCPtr(id));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool getNurbCurvesCache(OdGeCurve3dPtrArray arg0)
		{
			bool result = TD_DbPINVOKE.OdModelerGeometry_getNurbCurvesCache(this.swigCPtr, OdGeCurve3dPtrArray.getCPtr(arg0));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult setBody(IntPtr arg0)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setBody(this.swigCPtr, arg0);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual IntPtr body()
		{
			IntPtr result = TD_DbPINVOKE.OdModelerGeometry_body(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult setSubentColor(OdDbSubentId subentId, OdCmColor color)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setSubentColor(this.swigCPtr, OdDbSubentId.getCPtr(subentId), OdCmColor.getCPtr(color));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getSubentColor(OdDbSubentId subentId, OdCmColor color)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSubentColor(this.swigCPtr, OdDbSubentId.getCPtr(subentId), OdCmColor.getCPtr(color));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult setSubentMaterial(OdDbSubentId subentId, OdDbObjectId matId)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setSubentMaterial(this.swigCPtr, OdDbSubentId.getCPtr(subentId), OdDbObjectId.getCPtr(matId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getSubentMaterial(OdDbSubentId subentId, out ulong matId)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSubentMaterial(this.swigCPtr, OdDbSubentId.getCPtr(subentId), out matId);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult setSubentMaterialMapper(OdDbSubentId subentId, OdGeMatrix3d mx, out byte projection, out byte tiling, out byte autoTransform)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setSubentMaterialMapper(this.swigCPtr, OdDbSubentId.getCPtr(subentId), OdGeMatrix3d.getCPtr(mx), out projection, out tiling, out autoTransform);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getSubentMaterialMapper(OdDbSubentId subentId, OdGeMatrix3d mx, out byte projection, out byte tiling, out byte autoTransform)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSubentMaterialMapper(this.swigCPtr, OdDbSubentId.getCPtr(subentId), OdGeMatrix3d.getCPtr(mx), out projection, out tiling, out autoTransform);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult chamferEdges(OdDbSubentIdArray edgeSubentIds, OdDbSubentId baseFaceSubentId, double baseDist, double otherDist)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_chamferEdges(this.swigCPtr, OdDbSubentIdArray.getCPtr(edgeSubentIds), OdDbSubentId.getCPtr(baseFaceSubentId), baseDist, otherDist);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult filletEdges(OdDbSubentIdArray edgeSubentIds, OdGeDoubleArray radius, OdGeDoubleArray startSetback, OdGeDoubleArray endSetback)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_filletEdges(this.swigCPtr, OdDbSubentIdArray.getCPtr(edgeSubentIds), OdGeDoubleArray.getCPtr(radius), OdGeDoubleArray.getCPtr(startSetback), OdGeDoubleArray.getCPtr(endSetback));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createSectionObjects(OdGePlane sectionPlane, OdDbEntityPtrArray sectionObjects)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createSectionObjects(this.swigCPtr, OdGePlane.getCPtr(sectionPlane), OdDbEntityPtrArray.getCPtr(sectionObjects));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createInterferenceObjects(OdDbEntityPtrArray interferenceObjects, OdDbEntity pEntity, uint flags)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createInterferenceObjects(this.swigCPtr, OdDbEntityPtrArray.getCPtr(interferenceObjects), OdDbEntity.getCPtr(pEntity), flags);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult sliceByPlane(OdGePlane slicePlane, out OdDbSurface pNegHalfSurface, out OdDbSurface pNewSurface, bool bNotModifyItself)
		{
			IntPtr zero = IntPtr.Zero;
			IntPtr zero2 = IntPtr.Zero;
			OdResult result;
			try
			{
				OdResult odResult = (OdResult)TD_DbPINVOKE.OdModelerGeometry_sliceByPlane(this.swigCPtr, OdGePlane.getCPtr(slicePlane), out zero, out zero2, bNotModifyItself);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
				result = odResult;
			}
			finally
			{
				pNegHalfSurface = (OdDbSurface)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
				pNewSurface = (OdDbSurface)Teigha.Core.Helpers.odrxCreateObjectInternal(zero2, true);
			}
			return result;
		}

		public virtual OdResult sliceBySurface(OdDbSurface pSlicingSurface, out OdDbSurface pNegHalfSurface, out OdDbSurface pNewSurface, bool bNotModifyItself)
		{
			IntPtr zero = IntPtr.Zero;
			IntPtr zero2 = IntPtr.Zero;
			OdResult result;
			try
			{
				OdResult odResult = (OdResult)TD_DbPINVOKE.OdModelerGeometry_sliceBySurface(this.swigCPtr, OdDbSurface.getCPtr(pSlicingSurface), out zero, out zero2, bNotModifyItself);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
				result = odResult;
			}
			finally
			{
				pNegHalfSurface = (OdDbSurface)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
				pNewSurface = (OdDbSurface)Teigha.Core.Helpers.odrxCreateObjectInternal(zero2, true);
			}
			return result;
		}

		public virtual OdResult extrudeFaces(OdDbSubentIdArray faceSubentIds, double height, double taper)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrudeFaces(this.swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds), height, taper);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult extrudeFacesAlongPath(OdDbSubentIdArray faceSubentIds, OdDbCurve path)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrudeFacesAlongPath(this.swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds), OdDbCurve.getCPtr(path));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult ChangeFacesDoubleSidedParam(bool isDoubleSided)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_ChangeFacesDoubleSidedParam(this.swigCPtr, isDoubleSided);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult convertToNurbSurface(OdDbNurbSurfaceArray nurbSurfaceArray)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_convertToNurbSurface(this.swigCPtr, OdDbNurbSurfaceArray.getCPtr(nurbSurfaceArray));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult get(out int iUDegree, out int iVDegree, out bool bRational, out int iUNumControlPoints, out int iVNumControlPoints, OdGePoint3dArray ctrlPtsArr, OdGeDoubleArray weights, OdGeKnotVector uKnots, OdGeKnotVector vKnots)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_get(this.swigCPtr, out iUDegree, out iVDegree, out bRational, out iUNumControlPoints, out iVNumControlPoints, OdGePoint3dArray.getCPtr(ctrlPtsArr), OdGeDoubleArray.getCPtr(weights), OdGeKnotVector.getCPtr(uKnots), OdGeKnotVector.getCPtr(vKnots));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult set(int iUDegree, int iVDegree, bool bRational, int iUNumControlPoints, int iVNumControlPoints, OdGePoint3dArray ctrlPtsArr, OdGeDoubleArray weights, OdGeKnotVector uKnots, OdGeKnotVector vKnots)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_set(this.swigCPtr, iUDegree, iVDegree, bRational, iUNumControlPoints, iVNumControlPoints, OdGePoint3dArray.getCPtr(ctrlPtsArr), OdGeDoubleArray.getCPtr(weights), OdGeKnotVector.getCPtr(uKnots), OdGeKnotVector.getCPtr(vKnots));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getNumberOfControlPointsInU(out int iCount)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNumberOfControlPointsInU(this.swigCPtr, out iCount);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getNumberOfControlPointsInV(out int iCount)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNumberOfControlPointsInV(this.swigCPtr, out iCount);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getNumberOfKnotsInU(out int iCount)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNumberOfKnotsInU(this.swigCPtr, out iCount);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getNumberOfKnotsInV(out int iCount)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNumberOfKnotsInV(this.swigCPtr, out iCount);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getUKnots(OdGeKnotVector knots)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getUKnots(this.swigCPtr, OdGeKnotVector.getCPtr(knots));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getVKnots(OdGeKnotVector knots)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getVKnots(this.swigCPtr, OdGeKnotVector.getCPtr(knots));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getDegreeInU(out int iDegree)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getDegreeInU(this.swigCPtr, out iDegree);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getDegreeInV(out int iDegree)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getDegreeInV(this.swigCPtr, out iDegree);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult isClosedInU(out bool bIsClosed)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isClosedInU(this.swigCPtr, out bIsClosed);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult isClosedInV(out bool bIsClosed)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isClosedInV(this.swigCPtr, out bIsClosed);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult isPeriodicInU(out bool bIsPeriodic)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isPeriodicInU(this.swigCPtr, out bIsPeriodic);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult isPeriodicInV(out bool bIsPeriodic)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isPeriodicInV(this.swigCPtr, out bIsPeriodic);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getPeriodInU(out double dPeriod)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getPeriodInU(this.swigCPtr, out dPeriod);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getPeriodInV(out double dPeriod)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getPeriodInV(this.swigCPtr, out dPeriod);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult evaluate(double dU, double dV, OdGePoint3d pos)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_evaluate__SWIG_0(this.swigCPtr, dU, dV, OdGePoint3d.getCPtr(pos));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult evaluate(double dU, double dV, OdGePoint3d pos, OdGeVector3d uDeriv, OdGeVector3d vDeriv)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_evaluate__SWIG_1(this.swigCPtr, dU, dV, OdGePoint3d.getCPtr(pos), OdGeVector3d.getCPtr(uDeriv), OdGeVector3d.getCPtr(vDeriv));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult evaluate(double dU, double dV, OdGePoint3d pos, OdGeVector3d uDeriv, OdGeVector3d vDeriv, OdGeVector3d uuDeriv, OdGeVector3d uvDeriv, OdGeVector3d vvDeriv)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_evaluate__SWIG_2(this.swigCPtr, dU, dV, OdGePoint3d.getCPtr(pos), OdGeVector3d.getCPtr(uDeriv), OdGeVector3d.getCPtr(vDeriv), OdGeVector3d.getCPtr(uuDeriv), OdGeVector3d.getCPtr(uvDeriv), OdGeVector3d.getCPtr(vvDeriv));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult evaluate(double dU, double dV, int iDerivDegree, OdGePoint3d point, OdGeVector3dArray derivatives)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_evaluate__SWIG_3(this.swigCPtr, dU, dV, iDerivDegree, OdGePoint3d.getCPtr(point), OdGeVector3dArray.getCPtr(derivatives));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult isRational(out bool bIsRational)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isRational(this.swigCPtr, out bIsRational);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult isPlanar(out bool bIsPlanar, OdGePoint3d ptOnSurface, OdGeVector3d normal)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isPlanar(this.swigCPtr, out bIsPlanar, OdGePoint3d.getCPtr(ptOnSurface), OdGeVector3d.getCPtr(normal));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult isPointOnSurface(OdGePoint3d point, out bool bOnSurface)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isPointOnSurface(this.swigCPtr, OdGePoint3d.getCPtr(point), out bOnSurface);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getNormal(double dU, double dV, OdGeVector3d normal)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNormal(this.swigCPtr, dU, dV, OdGeVector3d.getCPtr(normal));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getNumberOfSpansInU(out int iSpan)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNumberOfSpansInU(this.swigCPtr, out iSpan);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getNumberOfSpansInV(out int iSpan)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNumberOfSpansInV(this.swigCPtr, out iSpan);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getIsolineAtU(double dNumberSegments, OdDbCurvePtrArray lineSegments)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getIsolineAtU(this.swigCPtr, dNumberSegments, OdDbCurvePtrArray.getCPtr(lineSegments));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getIsolineAtV(double dNumberSegments, OdDbCurvePtrArray lineSegments)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getIsolineAtV(this.swigCPtr, dNumberSegments, OdDbCurvePtrArray.getCPtr(lineSegments));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult InsertKnot(double dVal, int iUorV)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_InsertKnot(this.swigCPtr, dVal, iUorV);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult InsertControlPointsAtU(double dU, OdGePoint3dArray vCtrlPts, OdGeDoubleArray vWeights)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_InsertControlPointsAtU(this.swigCPtr, dU, OdGePoint3dArray.getCPtr(vCtrlPts), OdGeDoubleArray.getCPtr(vWeights));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult InsertControlPointsAtV(double dV, OdGePoint3dArray uCtrlPts, OdGeDoubleArray uWeights)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_InsertControlPointsAtV(this.swigCPtr, dV, OdGePoint3dArray.getCPtr(uCtrlPts), OdGeDoubleArray.getCPtr(uWeights));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult RemoveControlPointsAtU(int iUDegree)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_RemoveControlPointsAtU(this.swigCPtr, iUDegree);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult RemoveControlPointsAtV(int iVDegree)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_RemoveControlPointsAtV(this.swigCPtr, iVDegree);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult rebuild(int iUDegree, int iVDegree, int iNumUCtrlPts, int iNumVCtrlPts, bool bRestore)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_rebuild(this.swigCPtr, iUDegree, iVDegree, iNumUCtrlPts, iNumVCtrlPts, bRestore);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult modifyPositionAndTangent(double dU, double dV, OdGePoint3d point, OdGeVector3d uDeriv, OdGeVector3d vDeriv)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_modifyPositionAndTangent(this.swigCPtr, dU, dV, OdGePoint3d.getCPtr(point), OdGeVector3d.getCPtr(uDeriv), OdGeVector3d.getCPtr(vDeriv));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getParameterOfPoint(OdGePoint3d point, out double dU, out double dV)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getParameterOfPoint(this.swigCPtr, OdGePoint3d.getCPtr(point), out dU, out dV);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getControlPoints(out int iUCount, out int iVCount, OdGePoint3dArray points)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getControlPoints(this.swigCPtr, out iUCount, out iVCount, OdGePoint3dArray.getCPtr(points));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult setControlPoints(int iUCount, int iVCount, OdGePoint3dArray points)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setControlPoints(this.swigCPtr, iUCount, iVCount, OdGePoint3dArray.getCPtr(points));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getControlPointAndWeight(int iUIndex, int iVIndex, OdGePoint3d point, out double weight, out bool bIsRational)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getControlPointAndWeight(this.swigCPtr, iUIndex, iVIndex, OdGePoint3d.getCPtr(point), out weight, out bIsRational);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult setControlPointAndWeight(int iUIndex, int iVIndex, OdGePoint3d point, double weight)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setControlPointAndWeight(this.swigCPtr, iUIndex, iVIndex, OdGePoint3d.getCPtr(point), weight);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult setColorToSubents(OdCmColor color)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setColorToSubents(this.swigCPtr, OdCmColor.getCPtr(color));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult setMaterialToSubents(OdDbObjectId materialId)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setMaterialToSubents(this.swigCPtr, OdDbObjectId.getCPtr(materialId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult setMaterialResolver(SWIGTYPE_p_OdMaterialResolver pResolver)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setMaterialResolver(this.swigCPtr, SWIGTYPE_p_OdMaterialResolver.getCPtr(pResolver));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult setMaterialMapperToSubents(OdGeMatrix3d mx, out byte projection, out byte tiling, out byte autoTransform)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setMaterialMapperToSubents(this.swigCPtr, OdGeMatrix3d.getCPtr(mx), out projection, out tiling, out autoTransform);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult generateSectionGeometry(OdDbSection pSection, OdDbEntityPtrArray sourceEntArr, SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDbEntity_t_OdObjectsAllocatorT_OdSmartPtrT_OdDbEntity_t_t_t intBoundaryEnts, SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDbEntity_t_OdObjectsAllocatorT_OdSmartPtrT_OdDbEntity_t_t_t intFillEnts, SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDbEntity_t_OdObjectsAllocatorT_OdSmartPtrT_OdDbEntity_t_t_t backgroundEnts, SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDbEntity_t_OdObjectsAllocatorT_OdSmartPtrT_OdDbEntity_t_t_t foregroundEnts, SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDbEntity_t_OdObjectsAllocatorT_OdSmartPtrT_OdDbEntity_t_t_t curveTangencyEnts, bool bIsSetProperties)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_generateSectionGeometry__SWIG_0(this.swigCPtr, OdDbSection.getCPtr(pSection), OdDbEntityPtrArray.getCPtr(sourceEntArr), SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDbEntity_t_OdObjectsAllocatorT_OdSmartPtrT_OdDbEntity_t_t_t.getCPtr(intBoundaryEnts), SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDbEntity_t_OdObjectsAllocatorT_OdSmartPtrT_OdDbEntity_t_t_t.getCPtr(intFillEnts), SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDbEntity_t_OdObjectsAllocatorT_OdSmartPtrT_OdDbEntity_t_t_t.getCPtr(backgroundEnts), SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDbEntity_t_OdObjectsAllocatorT_OdSmartPtrT_OdDbEntity_t_t_t.getCPtr(foregroundEnts), SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDbEntity_t_OdObjectsAllocatorT_OdSmartPtrT_OdDbEntity_t_t_t.getCPtr(curveTangencyEnts), bIsSetProperties);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult trimSurface(OdDbObjectIdArray toolIds, OdDbObjectIdArray toolCurveIds, OdGeVector3dArray projVectors, OdGePoint3d pickPoint, OdGeVector3d viewVector, bool bAutoExtend, bool bAssociativeEnabled)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_trimSurface(this.swigCPtr, OdDbObjectIdArray.getCPtr(toolIds), OdDbObjectIdArray.getCPtr(toolCurveIds), OdGeVector3dArray.getCPtr(projVectors), OdGePoint3d.getCPtr(pickPoint), OdGeVector3d.getCPtr(viewVector), bAutoExtend, bAssociativeEnabled);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult projectOnToEntity(OdDbEntity pEntityToProject, OdGeVector3d projectionDirection, OdDbEntityPtrArray projectedEntities)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_projectOnToEntity(this.swigCPtr, OdDbEntity.getCPtr(pEntityToProject), OdGeVector3d.getCPtr(projectionDirection), OdDbEntityPtrArray.getCPtr(projectedEntities));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createSculptedSolid(OdDbEntityPtrArray limitingBodies, OdIntArray limitingFlags)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createSculptedSolid(this.swigCPtr, OdDbEntityPtrArray.getCPtr(limitingBodies), OdIntArray.getCPtr(limitingFlags).Handle);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult rayTest(OdGePoint3d rayBasePoint, OdGeVector3d rayDir, double rayRadius, OdDbSubentIdArraySt subEntIds, OdGeDoubleArray parameters)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_rayTest(this.swigCPtr, OdGePoint3d.getCPtr(rayBasePoint), OdGeVector3d.getCPtr(rayDir), rayRadius, OdDbSubentIdArraySt.getCPtr(subEntIds), OdGeDoubleArray.getCPtr(parameters));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult createFilletSurface(out OdDbSurface surf1, OdGePoint3d pickPt1, out OdDbSurface surf2, OdGePoint3d pickPt2, double dRadius, FilletTrimMode trimMode, OdGeVector3d projDir)
		{
			IntPtr zero = IntPtr.Zero;
			IntPtr zero2 = IntPtr.Zero;
			OdResult result;
			try
			{
				OdResult odResult = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createFilletSurface(this.swigCPtr, out zero, OdGePoint3d.getCPtr(pickPt1), out zero2, OdGePoint3d.getCPtr(pickPt2), dRadius, (int)trimMode, OdGeVector3d.getCPtr(projDir));
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
				result = odResult;
			}
			finally
			{
				surf1 = (OdDbSurface)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
				surf2 = (OdDbSurface)Teigha.Core.Helpers.odrxCreateObjectInternal(zero2, true);
			}
			return result;
		}

		public virtual OdResult extendEdges(OdDbFullSubentPathArray edgesId, double dExtDist, EdgeExtensionType extOption)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extendEdges(this.swigCPtr, OdDbFullSubentPathArray.getCPtr(edgesId), dExtDist, (int)extOption);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getObjectMesh(MeshFaceterSettings faceter, OdGePoint3dArray vertexArray, OdInt32Array faceArray, out FaceData faceData)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getObjectMesh(this.swigCPtr, MeshFaceterSettings.getCPtr(faceter), OdGePoint3dArray.getCPtr(vertexArray), OdInt32Array.getCPtr(faceArray).Handle, out faceData);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getBoundingBox(OdGeExtents3d box)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getBoundingBox(this.swigCPtr, OdGeExtents3d.getCPtr(box));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult generateSectionGeometry(SWIGTYPE_p_SectArgs sectArgs, OdDbEntity pEnt, out bool bHasForeground)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdModelerGeometry_generateSectionGeometry__SWIG_1(this.swigCPtr, SWIGTYPE_p_SectArgs.getCPtr(sectArgs), OdDbEntity.getCPtr(pEnt), out bHasForeground);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public const int kNothing = 0;

		public const int kIsolines = 1;

		public const int kEdges = 2;

		public const int kShells = 4;

		public const int kOrderedEdges = 8;

		public const int kSurfIsolines = 16;

		private object locker = new object();

		private HandleRef swigCPtr;

		public class NumIsolines : IDisposable
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public NumIsolines(IntPtr cPtr, bool cMemoryOwn)
			{
				this.swigCMemOwn = cMemoryOwn;
				this.swigCPtr = new HandleRef(this, cPtr);
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			public static HandleRef getCPtr(OdModelerGeometry.NumIsolines obj)
			{
				if (obj != null)
				{
					return obj.swigCPtr;
				}
				return new HandleRef(null, IntPtr.Zero);
			}

			~NumIsolines()
			{
				this.Dispose();
			}

			public virtual void Dispose()
			{
				if (this.swigCPtr.Handle != IntPtr.Zero)
				{
					if (this.swigCMemOwn)
					{
						lock (this.locker)
						{
							if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
							{
								this.swigCMemOwn = false;
								TD_DbPINVOKE.delete_OdModelerGeometry_NumIsolines(this.swigCPtr);
							}
						}
						this.swigCMemOwn = false;
					}
					this.swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}

			public uint numU
			{
				get
				{
					uint result = TD_DbPINVOKE.OdModelerGeometry_NumIsolines_numU_get(this.swigCPtr);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
					return result;
				}
				set
				{
					TD_DbPINVOKE.OdModelerGeometry_NumIsolines_numU_set(this.swigCPtr, value);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
				}
			}

			public uint numV
			{
				get
				{
					uint result = TD_DbPINVOKE.OdModelerGeometry_NumIsolines_numV_get(this.swigCPtr);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
					return result;
				}
				set
				{
					TD_DbPINVOKE.OdModelerGeometry_NumIsolines_numV_set(this.swigCPtr, value);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
				}
			}

			public NumIsolines() : this(TD_DbPINVOKE.new_OdModelerGeometry_NumIsolines(), true)
			{
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			private object locker = new object();

			private HandleRef swigCPtr;

			protected bool swigCMemOwn;
		}

		public enum MaterialState
		{
			kNoMaterials,
			kHasMaterials,
			kUnknown
		}

		public enum geomType
		{
			kUndefined,
			kBody,
			kSolid,
			kRegion,
			kSurface
		}
	}
}
